package net.xdclass.service.impl;

import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import lombok.extern.slf4j.Slf4j;
import net.xdclass.component.StoreEngine;
import net.xdclass.config.MinioConfig;
import net.xdclass.controller.req.*;
import net.xdclass.dto.AccountFileDTO;
import net.xdclass.dto.FolderTreeNodeDTO;
import net.xdclass.enums.BizCodeEnum;
import net.xdclass.enums.FileTypeEnum;
import net.xdclass.enums.FolderFlagEnum;
import net.xdclass.exception.BizException;
import net.xdclass.mapper.AccountFileMapper;
import net.xdclass.mapper.AccountMapper;
import net.xdclass.mapper.FileMapper;
import net.xdclass.mapper.StorageMapper;
import net.xdclass.model.AccountFileDO;
import net.xdclass.model.FileDO;
import net.xdclass.model.StorageDO;
import net.xdclass.service.AccountFileService;
import net.xdclass.util.CommonUtil;
import net.xdclass.util.SpringBeanUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.LongStream;

/**
 * @author 姜阿木
 * @date 2025/6/19 19:47
 */
@Service
@Slf4j
public class AccountFileServiceImpl implements AccountFileService {

    @Autowired
    private AccountFileMapper accountFileMapper;

    @Autowired
    private AccountMapper accountMapper;

    @Autowired
    private StoreEngine fileStoreEngine;

    @Autowired
    private MinioConfig minioConfig;

    @Autowired
    private FileMapper fileMapper;

    @Autowired
    private StorageMapper storageMapper;


    /**
     * 获取文件列表
     *
     * @param accountId 用户ID
     * @param parentId  上级ID
     * @return 文件列表
     */
    @Override
    public List<AccountFileDTO> list(Long accountId, Long parentId) {
        List<AccountFileDO> accountFileDOList = accountFileMapper.selectList(new QueryWrapper<AccountFileDO>()
                .eq("account_id", accountId)
                .eq("parent_id", parentId)
                .orderByDesc("is_dir")
                .orderByDesc("gmt_create")
        );
        return SpringBeanUtil.copyProperties(accountFileDOList, AccountFileDTO.class);
    }


    /**
     * 创建文件夹
     *
     * @param req
     */
    @Override
    public Long createFolder(FolderCreateReq req) {
        AccountFileDTO accountFileDTO = AccountFileDTO.builder()
                .accountId(req.getAccountId())
                .fileName(req.getFolderName())
                .isDir(FolderFlagEnum.YES.getCode())
                .parentId(req.getParentId()).build();

        return  saveAccountFile(accountFileDTO);

    }

    /**
     * 重命名文件
     *
     * @param req 空
     */
    @Override
    public void renameFile(FileUpdateReq req) {
        // 检查文件是否存在
        AccountFileDO accountFileDO = accountFileMapper.selectOne(new QueryWrapper<AccountFileDO>()
                .eq("id", req.getFileId())
                .eq("account_id", req.getAccountId()));
        if (accountFileDO == null){
            log.error("文件不存在{}",req);
            throw new BizException(BizCodeEnum.FILE_NOT_EXISTS);
        }else {
            // 新旧文件名不能一样
            if (Objects.equals(accountFileDO.getFileName(), req.getFileName())){
                log.error("新旧文件名不能一样，{}",req);
                throw new BizException(BizCodeEnum.FILE_RENAME_REPEAT);
            }
            // 同级文件名不能一样
            Long countFile = accountFileMapper.selectCount(new QueryWrapper<AccountFileDO>()
                    .eq("file_name", req.getFileName())
                    .eq("account_id", req.getAccountId())
                    .eq("parent_id", accountFileDO.getParentId())
            );
            if (countFile > 0){
                log.error("文件名重复,{}",req);
                throw new BizException(BizCodeEnum.FILE_RENAME_REPEAT);
            }else {
                // 校验通过保存文件
                accountFileDO.setFileName(req.getFileName());
                accountFileMapper.updateById(accountFileDO);
            }
        }

    }


    /**
     * 获取文件树 (非递归)
     * 1、查询用户全部文件夹
     * 2、拼接文件树：构建一个map
     * @param accountId 用户ID
     * @return 文件树
     */
    @Override
    public List<FolderTreeNodeDTO> folderTree(Long accountId) {
        // 查询用户全部文件夹
        List<AccountFileDO> fileList = accountFileMapper.selectList(new QueryWrapper<AccountFileDO>()
                .eq("account_id", accountId)
                .eq("is_dir", FolderFlagEnum.YES.getCode())
        );

        if (CollectionUtils.isEmpty(fileList)){
            return List.of();
        }

        //构建一个map，key为fileId，value为file对象 相当于一个数据源
        Map<Long, FolderTreeNodeDTO> folderMap = fileList.stream().collect(Collectors.toMap
                (AccountFileDO::getId, accountFileDO -> FolderTreeNodeDTO
                        .builder()
                        .id(accountFileDO.getId())
                        .parentId(accountFileDO.getParentId())
                        .label(accountFileDO.getFileName())
                        .children(new ArrayList<>())
                        .build()
        ));

        // 构建文件树，遍历数据源，为每个文件夹找到子节点
        for (FolderTreeNodeDTO node : folderMap.values()){
            Long parentId = node.getParentId();

            if (parentId != null && folderMap.containsKey(parentId)){
                // 获取父节点
                FolderTreeNodeDTO parentNode = folderMap.get(parentId);
                // 获取对应的子节点并添加到父节点中
                parentNode.getChildren().add(node);
            }
        }

        // 过滤掉根节点
        List<FolderTreeNodeDTO> rootFolderList = folderMap.values().stream()
                .filter(node -> Objects.equals(node.getParentId(), 0L))
                .collect(Collectors.toList());

        return rootFolderList;
    }


    /**
     * 获取文件树 (非递归)
     * 1、查询用户全部文件夹
     * 2、拼接文件树：构建一个map
     * @param accountId 用户ID
     * @return 文件树
     */
    @Override
    public List<FolderTreeNodeDTO> folderTreeV2(Long accountId) {
        // 查询用户全部文件夹
        List<AccountFileDO> folderList = accountFileMapper.selectList(new QueryWrapper<AccountFileDO>()
                .eq("account_id", accountId)
                .eq("is_dir", FolderFlagEnum.YES.getCode())
        );

        if (CollectionUtils.isEmpty(folderList)){
            return List.of();
        }


        List<FolderTreeNodeDTO> folderTreeNodeDTOS = folderList.stream().map(file->{
            return FolderTreeNodeDTO.builder()
                    .id(file.getId())
                    .label(file.getFileName())
                    .parentId(file.getParentId())
                    .children(new ArrayList<>())
                    .build();
        }).toList();
        //根据父文件夹进行分组 key是当前文件夹ID，value是当前文件夹下的所有文件夹
        Map<Long, List<FolderTreeNodeDTO>> folderTreeNodeVOMap = folderTreeNodeDTOS.stream()
                .collect(Collectors.groupingBy(FolderTreeNodeDTO::getParentId));

        // 遍历所有文件对象
        for (FolderTreeNodeDTO node : folderTreeNodeDTOS) {
            List<FolderTreeNodeDTO> children = folderTreeNodeVOMap.get(node.getId());
            // 判断列表是否为空
            if (!CollectionUtils.isEmpty(children)) {
                node.getChildren().addAll(children);
            }
        }
        return folderTreeNodeDTOS.stream().filter(node -> Objects.equals(node.getParentId(), 0L))
                .collect(Collectors.toList());
    }


    /**
     * 小文件上传
     * 1、存储到存储引擎
     * 2、保存文件和文件用户关系
     * @param req 文件上传请求
     */
    @Override
    public void fileUpload(FileUploadReq req) {
        // 检查存储空间是否足够
        boolean storageEnough = checkAndUpdateCapacity(req.getAccountId(),
                req.getFile() != null ? req.getFile().getSize() : req.getFileSize());
        if (storageEnough){
            // 存储到存储引擎,返回文件存储路径
            String storeFileObjectKey = storeFile(req);
            // 保存文件关系 + 保存账号和文件的关系
            saveFileAndAccountFile(req, storeFileObjectKey);
        }else
            throw new BizException(BizCodeEnum.FILE_STORAGE_NOT_ENOUGH);
    }

    /**
     * 检查存储空间并更新存储空间
     * @param accountId 用户ID
     * @param fileSize 文件大小
     * @return 是否足够
     */
    public boolean checkAndUpdateCapacity(Long accountId, Long fileSize) {
        StorageDO storageDO = storageMapper.selectOne(new QueryWrapper<StorageDO>().eq("account_id", accountId));
        if (fileSize + storageDO.getUsedSize() <= storageDO.getTotalSize()){
            storageDO.setUsedSize(fileSize + storageDO.getUsedSize());
            storageMapper.updateById(storageDO);
            return true;
        }else {
            return false;
        }
    }

    /**
     * 批量移动文件
     * 1、检查被移动的文件ID是否合法
     * 2、检查目标父文件夹ID是否合法
     * 3、批量移动文件到目标文件夹（重复名称处理）
     * @param req 文件批量移动请求
     */
    @Override
    public void moveBatch(FileBatchReq req) {
        //检查被移动的文件ID是否合法
        List<AccountFileDO> accountFileDOList = checkFileIDLegal(req.getFileIds(),req.getAccountId());

        //检查目标父文件夹ID是否合法
        checkTargetParentIDLegal(req);

        // 批量移动文件到目标文件夹
        accountFileDOList.forEach(accountFileDO -> accountFileDO.setParentId(req.getTargetFolderId()));

        //批量移动文件到目标文件夹（重复名称处理）
        accountFileDOList.forEach(this::processFileNameDuplicate);

        //更新文件或文件夹父文件ID为目标文件夹ID
//       for (AccountFileDO accountFileDO : accountFileDOList){
//           if (accountFileMapper.updateById(accountFileDO) < 0){
//               throw new BizException(BizCodeEnum.FILE_BATCH_UPDATE_ERROR);
//           }
//       }

        accountFileDOList.forEach(accountFileDO -> {
            Long selectCount = processFileNameDuplicate(accountFileDO);
            if (selectCount > 0) {
                accountFileMapper.updateById(accountFileDO);
            }
        });

    }


    /**
     * 批量删除文件
     * 1、检查被删除的文件ID是否合法
     * 2、判断是否是文件夹，文件夹需要递归获取子文件ID进行批量删除
     * 3、更新账号存储空间使用量
     * 4、批量删除账号映射文件，考虑回收站如何设计
     * @param req 文件批量删除请求
     */
    @Override
    @Transactional
    public void delBatch(FileDelReq req) {
        //1、检查被删除的文件ID是否合法
        List<AccountFileDO> accountFileDOList = checkFileIDLegal(req.getFileIds(), req.getAccountId());
        //2、判断是否是文件夹，文件夹需要递归获取子文件ID进行批量删除
        List<AccountFileDO> storeAccountFileDOS = new ArrayList<>();

        findAllAccountFileDOWithRecur(storeAccountFileDOS, accountFileDOList,false);

        //获取所有文件ID和文件夹 ID
        List<Long> allFiledIdList = storeAccountFileDOS.stream().map(AccountFileDO::getId).collect(Collectors.toList());

        //3、更新账号存储空间使用量 TODO 可以加个分布式锁,redisSion 可以用account_id作为锁力度
        long allFileSum = storeAccountFileDOS.stream()
                .filter(file -> file.getIsDir().equals(FolderFlagEnum.NO.getCode()))
                .mapToLong(AccountFileDO::getFileSize).sum();
        System.err.println("allFileSum:" + allFileSum);
        StorageDO storageDO = storageMapper.selectOne(new QueryWrapper<StorageDO>()
                .eq("account_id", req.getAccountId()));
        storageDO.setUsedSize(storageDO.getUsedSize() - allFileSum);
        storageMapper.updateById(storageDO);

        //4、批量删除账号映射文件，考虑回收站如何设计
        int delCount = accountFileMapper.deleteBatchIds(allFiledIdList);
        if (delCount != allFiledIdList.size()){
            throw new BizException(BizCodeEnum.FILE_BATCH_UPDATE_ERROR);
        }
    }

    /**
     * 批量复制文件
     * 1、检查被复制的文件ID是否合法
     * 2、检查目标父文件夹ID是否合法
     * 3、批量复制文件到目标文件夹（差异点 ID是全新的）
     * 4、计算存储空间使用量【差异点】
     * 5、存储相关记录
     * @param req 文件批量复制请求
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void copyBatch(FileBatchReq req) {
        //1、检查被复制的文件ID是否合法
        List<AccountFileDO> accountFileDOList = checkFileIDLegal(req.getFileIds(), req.getAccountId());
        //2、检查目标父文件夹ID是否合法
        checkTargetParentIDLegal(req);
        //3、批量复制文件到目标文件夹（差异点 ID是全新的） 核心点
        List<AccountFileDO> newAccountFileDOList = findBatchCopyWithRecur(accountFileDOList, req.getTargetFolderId());
        //4、计算存储空间使用量【差异点】
        Long totalFileSize = newAccountFileDOList
                .stream()
                .filter(file -> file.getIsDir().equals(FolderFlagEnum.NO.getCode()))
                .mapToLong(AccountFileDO::getFileSize).sum();
        if (!checkAndUpdateCapacity(req.getAccountId(),totalFileSize)){
            throw new BizException(BizCodeEnum.FILE_STORAGE_NOT_ENOUGH);
        }
        //5、存储相关记录
        accountFileMapper.insertFileBatch(newAccountFileDOList);
    }

    /**
     * 秒传文件
     * 1、检查文件是否存在
     * 2、检查存储空间是否足够
     * 3、存储相关记录
     * @param req 文件秒传请求
     * @return 是否秒传成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean secondUpload(FileSecondUploadReq req) {
        // 1、检查文件是否存在
        FileDO fileDO = fileMapper.selectOne(new QueryWrapper<FileDO>().eq("identifier", req.getIdentifier()));
        if (!Objects.equals(fileDO, null)){
            // 2、检查存储空间是否足够
            if (!checkAndUpdateCapacity(req.getAccountId(),fileDO.getFileSize())){
                throw new BizException(BizCodeEnum.FILE_STORAGE_NOT_ENOUGH);
            }
            // 3、存储相关记录
            AccountFileDTO accountFileDTO = new AccountFileDTO();
            accountFileDTO.setAccountId(req.getAccountId());
            accountFileDTO.setFileName(req.getFileName());
            accountFileDTO.setParentId(req.getParentId());
            accountFileDTO.setDel(false);
            accountFileDTO.setIsDir(FolderFlagEnum.NO.getCode());
            accountFileDTO.setFileSize(fileDO.getFileSize());
            accountFileDTO.setFileId(fileDO.getId());
            // 存储关联关系，里面会做相关检查
            saveAccountFile(accountFileDTO);
            return true;
        }
        return false;
    }


    /**
     * 批量复制文件
     * 包括递归处理，生成新的ID
     * @param accountFileDOList 批量操作的文件列表
      */
    public List<AccountFileDO> findBatchCopyWithRecur(List<AccountFileDO> accountFileDOList, Long targetFolderId) {
        // 存储
        List<AccountFileDO> newAccountFileDOList = new ArrayList<>();
        //遍历被复制的文件 核心点
        accountFileDOList.forEach(accountFileDO
                -> doCopyChildRecord(newAccountFileDOList, accountFileDO, targetFolderId));
        // 返回已复制的文件列表
        return newAccountFileDOList;
    }

    /**
     * 遍历到的每一个文件，递归处理包括子文件夹
     * @param newAccountFileDOList
     * @param accountFileDO
     * @param targetFolderId
     */
    private void doCopyChildRecord(List<AccountFileDO> newAccountFileDOList, AccountFileDO accountFileDO,
                                   Long targetFolderId) {
        // 旧文件ID,方便查找子文件夹
        Long oldAccountFileId = accountFileDO.getId();
        // 创建新文件记录
        accountFileDO.setId(IdUtil.getSnowflakeNextId());
        accountFileDO.setParentId(targetFolderId);
        accountFileDO.setGmtModified(null);
        accountFileDO.setGmtCreate(null);

        //处理重复文件名
        processFileNameDuplicate(accountFileDO);
        //添加到新文件列表
        newAccountFileDOList.add(accountFileDO);
        //判断是否是文件夹
        if (Objects.equals(accountFileDO.getIsDir(), FolderFlagEnum.YES.getCode())){
            //继续获取文件夹下的所有文件
            List<AccountFileDO> childAccountFileDOList = findChildAccountFile(accountFileDO.getAccountId(), oldAccountFileId);
            if (CollectionUtils.isEmpty(childAccountFileDOList)){
                return;
            }
            // 继续递归
            childAccountFileDOList.forEach(childAccountFileDO
                    -> doCopyChildRecord(newAccountFileDOList, childAccountFileDO, accountFileDO.getId()));
        }
    }

    /**
     * 查找被复制的文件下的所有文件and子文件夹
     * @param accountId 账号ID
     * @param parentId 旧文件ID
     * @return
     */

    private List<AccountFileDO> findChildAccountFile(Long accountId, Long parentId) {
        return accountFileMapper.selectList(new QueryWrapper<AccountFileDO>()
                .eq("parent_id", parentId)
                .eq("account_id", accountId));
    }


    /**
     * 检查目标父文件夹ID是否合法
     * 1、目标文件夹ID不能是文件
     * 2、要操作的的文件列表，不能包含目标文件ID
     * @param req 文件批量移动请求
     */
    private void checkTargetParentIDLegal(FileBatchReq req) {
        // 目标文件夹ID不能是文件
        AccountFileDO TargetAccountFileDO = accountFileMapper.selectOne(new QueryWrapper<AccountFileDO>()
                .eq("id", req.getTargetFolderId())
                .eq("is_dir", FolderFlagEnum.YES.getCode())
                .eq("account_id", req.getAccountId()));
        if (TargetAccountFileDO ==  null){
            log.error("目标文件夹ID不存在或者不是文件夹,id={}", req.getTargetFolderId());
            throw new BizException(BizCodeEnum.FILE_TARGET_PARENT_ILLEGAL);
        }

        /**
         * 要操作的的文件列表，不能包含目标文件ID
         * 1、查询批量操作的文件夹和子文件夹，递归处理
         * 2、判断是否在里面
         */
        List<AccountFileDO> prepareAccountFileDOS = accountFileMapper.selectList(new QueryWrapper<AccountFileDO>()
                .in("id", req.getFileIds())
                .eq("account_id", req.getAccountId()));

        // 定义一个容器，存储全部文件夹，包含子文件夹
        List<AccountFileDO> allAccountFileDOS = new ArrayList<>();
        // 递归查询全部文件夹，包含子文件夹
        findAllAccountFileDOWithRecur(allAccountFileDOS,prepareAccountFileDOS,false);

        //判断是否在里面
        if (allAccountFileDOS.stream().anyMatch(accountFileDO -> Objects.equals(accountFileDO.getId(), req.getTargetFolderId()))){
            log.error("要操作的文件列表，不能包含目标文件ID,fileIds={},targetFolderId={}",
                    req.getFileIds(), req.getTargetFolderId());
            throw new BizException(BizCodeEnum.FILE_TARGET_PARENT_ILLEGAL);
        }

    }

    /**
     * 递归查询全部文件夹，包含子文件夹
     * @param allAccountFileDOS 容器，存储全部文件夹或文件
     * @param prepareAccountFileDOS 待处理的文件夹或文件
     * @param onlyFolder 是否只处理文件夹
     */
    // 递归查询全部文件夹，包含子文件夹
    public void findAllAccountFileDOWithRecur(List<AccountFileDO> allAccountFileDOS, List<AccountFileDO> prepareAccountFileDOS, boolean onlyFolder) {
        for (AccountFileDO accountFileDO : prepareAccountFileDOS){
            if (Objects.equals(accountFileDO.getIsDir(), FolderFlagEnum.YES.getCode())){
                // 递归查找
                List<AccountFileDO> childAccountFileDOS = accountFileMapper.selectList(new QueryWrapper<AccountFileDO>()
                        .eq("parent_id", accountFileDO.getId()));
                findAllAccountFileDOWithRecur(allAccountFileDOS, childAccountFileDOS, onlyFolder);
            }
            //如果onlyFolder为true，则只处理文件夹存储到allAccountFileDOS中，否则都存储到allAccountFileDOS中
            if (!onlyFolder || Objects.equals(accountFileDO.getIsDir(), FolderFlagEnum.YES.getCode())){
                allAccountFileDOS.add(accountFileDO);
            }
        }
    }

    /**
     * 检查被移动的文件ID是否合法
     * @param fileIds 文件ID列表
     * @param accountId 用户ID
     * @return 文件列表
     */
    @Override
    public List<AccountFileDO> checkFileIDLegal(List<Long> fileIds, Long accountId) {
        List<AccountFileDO> accountFileDOList = accountFileMapper.selectList(new QueryWrapper<AccountFileDO>()
                .eq("account_id", accountId)
                .in("id", fileIds)
        );
        if (accountFileDOList.size() != fileIds.size()){
            log.error("文件ID数量不合法,ids={}", fileIds);
            throw new BizException(BizCodeEnum.FILE_BATCH_UPDATE_ERROR);
        }
        // 进一步完善，可以加个set，防止重复
        return accountFileDOList;
    }

    private String storeFile(FileUploadReq req) {
        String objectKey = CommonUtil.getFilePath(req.getFileName());
        fileStoreEngine.upload(minioConfig.getBucketName(), objectKey, req.getFile());
        return objectKey;
    }

    // 保存文件关系 + 保存账号和文件的关系
    @Override
    public void saveFileAndAccountFile(FileUploadReq req, String storeFileObjectKey) {
        // 1、保存文件
        FileDO fileDO = saveFile(req, storeFileObjectKey);
        // 2、保存账号和文件关系
        AccountFileDTO accountFileDTO = AccountFileDTO.builder()
                .accountId(req.getAccountId())
                .fileId(fileDO.getId())
                .fileName(req.getFileName())
                .fileType(FileTypeEnum.fromExtension(fileDO.getFileSuffix()).name())
                .fileSuffix(CommonUtil.getFileSuffix(req.getFileName()))
                .fileSize(fileDO.getFileSize())
                .parentId(req.getParentId())
                .isDir(FolderFlagEnum.NO.getCode())
                .build();
        saveAccountFile(accountFileDTO);

    }

    /**
     * 保存文件
     * @param req 文件信息
     * @param storeFileObjectKey 文件存储路径
     * @return 文件对象
     */
    private FileDO saveFile(FileUploadReq req, String storeFileObjectKey) {
        FileDO fileDO = new FileDO();
        fileDO.setAccountId(req.getAccountId());
        fileDO.setFileName(req.getFileName());
        fileDO.setFileSize(req.getFile() != null ? req.getFile().getSize() : req.getFileSize());
        fileDO.setFileSuffix(CommonUtil.getFileSuffix(req.getFileName()));
        fileDO.setIdentifier(req.getIdentifier());
        fileDO.setObjectKey(storeFileObjectKey);
        fileMapper.insert(fileDO);
        return fileDO;
    }


    /**
     * 处理用户和文件的关系，存储文件或文件夹
     * 1、检查父文件是否存在
     * 2、检查文件名是否重复
     * 3、保存用户和文件的关系
     * @param accountFileDTO  文件信息
     * @return 文件ID
     */
    private Long saveAccountFile(AccountFileDTO accountFileDTO) {
        // 检查父文件是否存在
        checkParentFileId(accountFileDTO);

        AccountFileDO accountFileDO = SpringBeanUtil.copyProperties(accountFileDTO, AccountFileDO.class);
        // 检查文件名是否重复 aa aa(1) aa(2)
        processFileNameDuplicate(accountFileDO);

        // 保存用户和文件关系
        accountFileMapper.insert(accountFileDO);
        return accountFileDO.getId();
    }


    //  处理文件夹重复 or 处理文件名重复
    public Long processFileNameDuplicate(AccountFileDO accountFileDO) {
        Long selectCount = accountFileMapper.selectCount(new QueryWrapper<AccountFileDO>()
                .eq("account_id", accountFileDO.getAccountId())
                .eq("parent_id", accountFileDO.getParentId())
                .eq("file_name", accountFileDO.getFileName())
                .eq("is_dir", accountFileDO.getIsDir())
        );
        if (selectCount > 0) {
            // 处理文件夹重复
            if (Objects.equals(accountFileDO.getIsDir(), FolderFlagEnum.YES.getCode())){
//                accountFileDO.setFileName(accountFileDO.getFileName() + "(1)");
                accountFileDO.setFileName(accountFileDO.getFileName() + "_" + System.currentTimeMillis());
            }else {
                // 处理文件名重复
                String[] split = accountFileDO.getFileName().split("\\.");
                accountFileDO.setFileName(split[0] + "_" + System.currentTimeMillis() + "."  + split[1]);
            }
        }
        return selectCount;
    }


    // 检查父文件ID是否存在
    private void checkParentFileId(AccountFileDTO accountFileDTO) {
        // 根据前端传递的父文件ID查询数据库
        if (accountFileDTO.getParentId() != 0 ){
            AccountFileDO accountFileDO = accountFileMapper.selectOne(new QueryWrapper<AccountFileDO>()
                    .eq("id", accountFileDTO.getParentId())
                    .eq("account_id", accountFileDTO.getAccountId()));

            //如果查库中没有该文件ID，则报错
            if (accountFileDO == null){
                throw new BizException(BizCodeEnum.FILE_NOT_EXISTS);
            }
        }
    }
}
